// SmartInput 浏览器扩展后台脚本

// Socket.io客户端库代码 (内联版本)
// 为了避免importScripts在Service Worker中的限制，直接包含Socket.io代码
(function() {
  // 简化的Socket.io客户端实现
  self.io = self.io || function(url, options) {
    return new SocketIOClient(url, options);
  };

  function SocketIOClient(url, options) {
    this.url = url;
    this.options = options || {};
    this.connected = false;
    this.socket = null;
    this.eventListeners = {};
  }

  SocketIOClient.prototype.connect = function() {
    const wsUrl = this.url.replace(/^https?:\/\//, 'ws://') + '/socket.io/?EIO=4&transport=websocket';
    this.socket = new WebSocket(wsUrl);
    
    this.socket.onopen = () => {
      this.connected = true;
      this.socket.send('40'); // Socket.io namespace connect
      this.emit('connect');
    };

    this.socket.onmessage = (event) => {
      this.handleMessage(event.data);
    };

    this.socket.onclose = () => {
      this.connected = false;
      this.emit('disconnect');
    };

    this.socket.onerror = (error) => {
      this.emit('connect_error', error);
    };
  };

  SocketIOClient.prototype.handleMessage = function(data) {
    if (typeof data === 'string') {
      if (data.startsWith('0')) {
        // Socket.io握手响应
        return;
      }
      if (data.startsWith('42')) {
        // Socket.io事件消息
        try {
          const jsonData = data.substring(2);
          const [eventName, eventData] = JSON.parse(jsonData);
          this.emit(eventName, eventData);
        } catch (e) {
          console.error('解析Socket.io消息失败:', e);
        }
        return;
      }
      if (data === '2') {
        // 心跳消息
        this.socket.send('3'); // 回复心跳
        return;
      }
    }
  };

  SocketIOClient.prototype.emit = function(eventName, data) {
    if (this.connected && this.socket) {
      const message = JSON.stringify([eventName, data]);
      this.socket.send('42' + message);
    }
  };

  SocketIOClient.prototype.on = function(eventName, callback) {
    if (!this.eventListeners[eventName]) {
      this.eventListeners[eventName] = [];
    }
    this.eventListeners[eventName].push(callback);
  };

  SocketIOClient.prototype.emit = function(eventName, data) {
    if (this.eventListeners[eventName]) {
      this.eventListeners[eventName].forEach(callback => {
        try {
          callback(data);
        } catch (e) {
          console.error('事件处理错误:', e);
        }
      });
    }
  };
})();

let ws = null;
let deviceId = null;
let isConnected = false;
let pairedDevices = new Set();
let currentServer = null;
let reconnectAttempts = 0;
let maxReconnectAttempts = 5;
let heartbeatInterval = null;
let isRegistering = false; // 添加注册状态跟踪

// 生成浏览器指纹唯一设备ID (Service Worker 兼容版本)
async function generateBrowserUniqueDeviceId() {
  try {
    // Service Worker 环境下无法访问 document 和 screen，使用其他可用特征
    
    // 获取时区信息
    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
    
    // 获取语言信息
    const language = navigator.language || 'en-US';
    
    // 获取用户代理信息（取部分）
    const userAgent = navigator.userAgent.substring(0, 50);
    
    // 获取平台信息
    const platform = navigator.platform || 'unknown';
    
    // 获取硬件并发数
    const hardwareConcurrency = navigator.hardwareConcurrency || 1;
    
    // 获取内存信息（如果可用）
    const deviceMemory = navigator.deviceMemory || 'unknown';
    
    // Service Worker 环境下的唯一标识
    const swVersion = 'sw_v1';
    
    // 组合所有特征
    const fingerprint = [
      timezone,
      language,
      userAgent,
      platform,
      hardwareConcurrency,
      deviceMemory,
      swVersion
    ].join('|');
    
    // 生成基于指纹的固定ID
    const hash = await generateSimpleHash(fingerprint);
    const browserId = hash.substring(0, 12);
    
    return `browser_chrome_${browserId}`;
  } catch (error) {
    console.warn('生成浏览器指纹失败，使用备用方案:', error);
    
    // 备用方案：使用 chrome.storage 存储的固定ID（Service Worker 兼容）
    try {
      const result = await chrome.storage.local.get(['smartinput_browser_id']);
      let storedId = result.smartinput_browser_id;
      
      if (!storedId) {
        storedId = Math.random().toString(36).substring(2, 14);
        await chrome.storage.local.set({ smartinput_browser_id: storedId });
        console.log('🆕 生成并存储新的浏览器ID:', storedId);
      } else {
        console.log('🔄 使用已存储的浏览器ID:', storedId);
      }
      
      return `browser_chrome_${storedId}`;
    } catch (storageError) {
      console.error('❌ chrome.storage 也失败，使用最终备用方案:', storageError);
      // 最终备用方案：使用当前时间戳生成（不稳定，但确保能工作）
      const fallbackId = Date.now().toString(36) + Math.random().toString(36).substring(2, 8);
      return `browser_chrome_${fallbackId}`;
    }
  }
}

// 简单哈希函数
async function generateSimpleHash(str) {
  const encoder = new TextEncoder();
  const data = encoder.encode(str);
  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map(b => b.toString(36)).join('').substring(0, 12);
}

// 生成设备ID（保留原函数作为备用）
function generateDeviceId() {
  const timestamp = Date.now();
  const random = Math.random().toString(36).substring(2, 15);
  return `browser_chrome_${timestamp}_${random}`;
}

// 生成增强的浏览器硬件指纹
async function generateEnhancedBrowserFingerprint() {
  try {
    // Service Worker 环境下不能用 screen/window/document，只用 navigator 信息
    const userAgent = (typeof navigator !== 'undefined' && navigator.userAgent) ? navigator.userAgent : 'no-navigator';
    const language = (typeof navigator !== 'undefined' && navigator.language) ? navigator.language : 'no-lang';
    // 可扩展更多 navigator 信息
    return [userAgent, language].join('|');
  } catch (e) {
    console.warn('生成增强浏览器指纹失败，使用备用方案:', e);
    return null;
  }
}

// 注册设备（服务端生成ID）
async function registerDeviceWithServerId() {
  try {
    console.log('🔄 开始设备注册（服务端生成ID）...');
    
    // 生成硬件指纹
    const hardwareFingerprint = await generateEnhancedBrowserFingerprint();
    
    // 准备设备信息
    const deviceInfo = {
      type: 'browser',
      name: 'Chrome Browser',
      capabilities: {
        canReceiveText: true,
        canSendVoice: false,
        canGenerateQR: true,
        canScanQR: false
      },
      hardwareFingerprint: hardwareFingerprint
    };
    
    console.log('📤 发送设备注册请求:', deviceInfo);
    
    // 发送注册请求
    if (currentServer && ws && ws.readyState === WebSocket.OPEN) {
      // 使用WebSocket - 等待注册完成
      return new Promise((resolve) => {
        const timeout = setTimeout(() => {
          console.warn('⚠️ WebSocket注册超时');
          resolve(false);
        }, 10000);
        
        const handleRegistered = (eventData) => {
          clearTimeout(timeout);
          if (eventData.success && eventData.deviceId) {
            deviceId = eventData.deviceId;
            chrome.storage.local.set({ deviceId });
            console.log('✅ WebSocket注册成功，设备ID:', deviceId);
            resolve(true);
          } else {
            console.error('❌ WebSocket注册失败:', eventData);
            resolve(false);
          }
          // 移除事件监听器
          if (ws) {
            ws.removeEventListener('message', handleMessage);
          }
        };
        
        const handleMessage = (event) => {
          try {
            const data = JSON.parse(event.data);
            if (data.type === 'device:registered') {
              handleRegistered(data);
            }
          } catch (error) {
            // 忽略解析错误
          }
        };
        
        if (ws) {
          ws.addEventListener('message', handleMessage);
        }
        
        sendMessage('device:register', deviceInfo);
      });
    } else if (currentServer) {
      // 使用HTTP API
      const response = await fetch(`${currentServer}/api/device/register`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        },
        body: JSON.stringify(deviceInfo)
      });
      
      if (response.ok) {
        const result = await response.json();
        if (result.success && result.deviceId) {
          deviceId = result.deviceId;
          await chrome.storage.local.set({ deviceId });
          console.log('✅ HTTP API注册成功，设备ID:', deviceId);
          return true;
        }
      }
    }
    
    return false;
  } catch (error) {
    console.error('❌ 设备注册失败:', error);
    return false;
  }
}

// 确保设备ID已初始化（更新版本）
async function ensureDeviceIdInitialized() {
  if (!deviceId) {
    console.log('🔧 设备ID未初始化，正在加载...');
    const result = await chrome.storage.local.get(['deviceId', 'pairedDevices']);
    
    if (!result.deviceId) {
      // 只生成本地ID，不进行服务端注册
      deviceId = await generateBrowserUniqueDeviceId();
      await chrome.storage.local.set({ deviceId });
      console.log('🆕 生成本地设备ID:', deviceId);
    } else {
      deviceId = result.deviceId;
      console.log('🔄 加载现有设备ID:', deviceId);
    }
    
    // 加载配对设备列表
    if (result.pairedDevices && Array.isArray(result.pairedDevices)) {
      pairedDevices = new Set(result.pairedDevices);
      console.log('🔄 加载配对设备列表:', Array.from(pairedDevices));
    }
  } else {
    console.log('✅ 设备ID已存在:', deviceId);
  }
}

// 获取可能的服务器地址
function getServerUrls() {
  // 注意：这个函数当前未在主连接逻辑中使用，但为了保持一致性我们进行修改
  return [
    'https://localhost:3001',
    'https://127.0.0.1:3001',
    'https://192.168.3.17:3001'
  ];
}

// 发送WebSocket消息
function sendMessage(type, data = {}) {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接，无法发送消息');
    return false;
  }

  const message = {
    type,
    data,
    timestamp: Date.now()
  };

  try {
    ws.send(JSON.stringify(message));
    console.log('📤 发送消息:', message);
    return true;
  } catch (error) {
    console.error('❌ 发送消息失败:', error);
    return false;
  }
}

// 连接到WebSocket服务器
async function connectToServer() {
  // 在连接前先确保设备ID已初始化
  await ensureDeviceIdInitialized();
  
  // 优先测试本地回环地址，然后是局域网IP
  const httpUrls = [
    'https://localhost:3001',
    'https://127.0.0.1:3001',
    'https://192.168.3.17:3001'
  ];

  for (const httpUrl of httpUrls) {
    try {
      console.log(`🔄 测试HTTP连接: ${httpUrl}`);

      // 为不同类型的连接设置不同的选项
      const fetchOptions = {
        method: 'GET',
        headers: {
          'Accept': 'application/json',
          'Content-Type': 'application/json'
        },
        // Chrome扩展Service Worker需要特殊处理
        mode: 'cors',
        credentials: 'omit',
        cache: 'no-cache'
      };

      // 使用AbortController而不是AbortSignal.timeout (兼容性更好)
      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), 5000);
      fetchOptions.signal = controller.signal;

      // 对于HTTPS连接，添加额外的错误处理
      let response;
      try {
        response = await fetch(`${httpUrl}/health`, fetchOptions);
        clearTimeout(timeoutId); // 清理超时定时器
      } catch (fetchError) {
        clearTimeout(timeoutId); // 清理超时定时器

        // 如果是HTTPS连接失败，提供更详细的错误信息
        if (httpUrl.startsWith('https://')) {
          console.log(`🔒 HTTPS连接失败: ${httpUrl}`);
          console.log(`💡 可能的原因: Service Worker网络限制或证书问题`);

          // 尝试使用不同的fetch选项
          console.log(`�� 尝试简化的fetch请求...`);
          try {
            const simpleResponse = await fetch(`${httpUrl}/health`, {
              method: 'GET',
              mode: 'no-cors' // 尝试no-cors模式
            });
            console.log(`✅ 简化请求成功: ${httpUrl}`);
            // no-cors模式下无法读取响应内容，但连接成功
            currentServer = httpUrl;
            isConnected = true;
            reconnectAttempts = 0;
            notifyConnectionStatus(true, httpUrl);
            console.log('📝 HTTP连接已建立 (no-cors模式)');
            
            // 尝试建立WebSocket连接
            try {
              await createWebSocketConnection(httpUrl);
            } catch (wsError) {
              console.log('⚠️ WebSocket连接失败，但HTTP连接可用:', wsError.message);
            }
            return;
          } catch (simpleError) {
            console.log(`❌ 简化请求也失败: ${simpleError.message}`);
          }

          throw new Error(`HTTPS连接失败: ${fetchError.message}`);
        }
        throw fetchError;
      }

      if (!response.ok) {
        console.log(`❌ HTTP连接失败: ${httpUrl} - ${response.status}`);
        continue;
      }

      console.log(`✅ HTTP连接成功: ${httpUrl}`);

      // 设置当前服务器
      currentServer = httpUrl;
      isConnected = true;
      reconnectAttempts = 0;

      // 通知popup连接状态
      notifyConnectionStatus(true, httpUrl);

      // 启动心跳保活
      startHeartbeat();

      // 尝试建立WebSocket连接
      try {
        await createWebSocketConnection(httpUrl);
        console.log('✅ WebSocket连接已建立');
      } catch (wsError) {
        console.log('⚠️ WebSocket连接失败，但HTTP连接可用:', wsError.message);
        // 即使WebSocket失败，HTTP连接仍然可用
      }

      return;

    } catch (error) {
      console.error(`❌ 连接失败: ${httpUrl}`, {
        name: error.name,
        message: error.message,
        stack: error.stack
      });

      // 特殊处理常见错误
      if (error.message.includes('Failed to fetch')) {
        if (httpUrl.startsWith('https://')) {
          console.log(`🔒 HTTPS证书问题: 请在浏览器中访问 ${httpUrl}/health 并接受证书`);
        } else {
          console.log(`🔒 可能的原因: 网络连接问题或服务器未启动`);
        }
      }

      continue;
    }
  }

  console.error('❌ 所有服务器连接失败');
  isConnected = false;
  currentServer = null;

  // 通知popup连接失败
  notifyConnectionStatus(false, null);

  // 重连逻辑
  if (reconnectAttempts < maxReconnectAttempts) {
    reconnectAttempts++;
    const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
    console.log(`🔄 ${delay/1000}秒后重试连接 (${reconnectAttempts}/${maxReconnectAttempts})`);
    setTimeout(connectToServer, delay);
  } else {
    console.error('❌ 达到最大重连次数，停止重连');
  }
}

// 心跳保活与连接检查
function startHeartbeat() {
  // 先清除旧的定时器，防止重复
  if (heartbeatInterval) {
    clearInterval(heartbeatInterval);
  }

  heartbeatInterval = setInterval(() => {
    if (!isConnected) {
      console.log('💓 心跳检测：连接已断开，尝试重连...');
      connectToServer(); // 如果连接丢失，则尝试重连
      return;
    }

    // 通过一个简单的HTTP请求来检查连接，因为它比WSS更不容易被意外中断
    fetch(`${currentServer}/health`)
      .then(response => {
        if (!response.ok) {
          throw new Error('心跳检测失败');
        }
        console.log('💓 心跳检测：连接正常');
      })
      .catch(() => {
        console.error('💓 心跳检测：服务器无响应，标记为未连接');
        isConnected = false;
        notifyConnectionStatus(false, null);
        // 清除定时器，等待下一次重连
        clearInterval(heartbeatInterval);
        heartbeatInterval = null;
      });
  }, 20000); // 每20秒检查一次
}

// 创建WebSocket连接
function createWebSocketConnection(url) {
  return new Promise((resolve, reject) => {
    try {
      // 构建正确的Socket.io WebSocket URL
      // 将HTTPS转换为WSS，HTTP转换为WS
      const wsUrl = url.replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://') + '/socket.io/?EIO=4&transport=websocket';
      console.log(`🔌 创建WebSocket连接: ${wsUrl}`);

      ws = new WebSocket(wsUrl);

      ws.onopen = () => {
        console.log(`🎉 WebSocket连接成功: ${url}`);
        isConnected = true;
        currentServer = url;
        reconnectAttempts = 0;

        // 发送Socket.io握手消息 (Engine.IO协议)
        ws.send('40'); // Socket.io namespace connect

        // 注册设备（只注册一次）
        setTimeout(() => registerDevice(), 1000);

        // 通知popup连接状态
        notifyConnectionStatus(true, url);

        // 连接成功后同步配对状态
        setTimeout(() => {
          syncPairingStatus();
        }, 2000);
        
        // 开始心跳
        startHeartbeat();

        resolve();
      };

      ws.onmessage = (event) => {
        handleWebSocketMessage(event.data);
      };

      ws.onclose = (event) => {
        console.log(`🔌 WebSocket连接关闭: ${event.code} - ${event.reason}`);
        isConnected = false;
        currentServer = null;
        notifyConnectionStatus(false, null);

        // 尝试重连
        setTimeout(connectToServer, 3000);
      };

      ws.onerror = (error) => {
        console.error(`❌ WebSocket错误:`, error);
        reject(error);
      };

    } catch (error) {
      console.error('❌ 创建WebSocket连接失败:', error);
      reject(error);
    }
  });
}

// 处理WebSocket消息
function handleWebSocketMessage(data) {
  try {
    console.log('📥 收到消息:', data);

    // Socket.io协议消息处理
    if (typeof data === 'string') {
      // Socket.io握手响应
      if (data.startsWith('0')) {
        console.log('✅ Socket.io握手成功');
        return;
      }

      // Socket.io事件消息
      if (data.startsWith('42')) {
        const jsonData = data.substring(2);
        const [eventName, eventData] = JSON.parse(jsonData);
        handleSocketEvent(eventName, eventData);
        return;
      }

      // 心跳消息
      if (data === '2') {
        ws.send('3'); // 回复心跳
        return;
      }
    }

  } catch (error) {
    console.error('❌ 处理消息失败:', error);
  }
}

// 处理Socket.io事件
function handleSocketEvent(eventName, eventData) {
  console.log(`📨 收到事件: ${eventName}`, eventData);

  switch (eventName) {
    case 'device:registered':
      console.log('✅ 设备注册成功:', eventData);
      isRegistering = false; // 重置注册状态
      if (eventData.success && eventData.deviceId) {
        deviceId = eventData.deviceId;
        chrome.storage.local.set({ deviceId });

        // 通知popup设备注册成功
        chrome.runtime.sendMessage({
          type: 'DEVICE_REGISTERED',
          deviceId: eventData.deviceId
        }).catch(() => {});
        
        // 注册成功后同步配对状态
        setTimeout(() => {
          syncPairingStatus();
        }, 1000);
      } else {
        console.error('❌ 设备注册失败:', eventData);
        isRegistering = false; // 注册失败时也重置状态
      }
      break;

    case 'pairing:code-generated':
      console.log('📱 配对码生成:', eventData);

      // 通知popup显示配对码
      chrome.runtime.sendMessage({
        type: 'PAIRING_CODE',
        code: eventData.code,
        qrCode: eventData.qrCode
      }).catch(() => {});
      break;

    case 'device:paired':
      console.log('🤝 设备配对成功:', eventData);
      
      // 统一处理配对设备ID，支持多种字段名
      let pairedDeviceId = null;
      if (eventData.deviceId) {
        pairedDeviceId = eventData.deviceId;
      } else if (eventData.mobileDeviceId) {
        pairedDeviceId = eventData.mobileDeviceId;
      }
      
      if (pairedDeviceId) {
        pairedDevices.add(pairedDeviceId);
        console.log('📱 更新配对设备列表:', Array.from(pairedDevices));
        
        // 保存配对设备列表到本地存储
        chrome.storage.local.set({ pairedDevices: Array.from(pairedDevices) });

        // 通知popup更新配对设备列表，传递完整的设备信息
        chrome.runtime.sendMessage({
          type: 'DEVICE_PAIRED',
          device: {
            deviceId: pairedDeviceId,
            deviceName: eventData.deviceName || '移动设备',
            mobileDeviceId: pairedDeviceId // 保持向后兼容
          }
        }).catch(() => {});
      } else {
        console.warn('⚠️ 配对事件中未找到设备ID:', eventData);
      }
      break;

    case 'voice:text':
      console.log('🎤 收到语音文本:', eventData);
      handleVoiceText(eventData);
      break;

    default:
      console.log('❓ 未知事件:', eventName, eventData);
  }
}

// 发送Socket.io事件
function emitSocketEvent(eventName, eventData) {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接，无法发送事件');
    return false;
  }

  try {
    const message = `42${JSON.stringify([eventName, eventData])}`;
    ws.send(message);
    console.log(`📤 发送事件: ${eventName}`, eventData);
    return true;
  } catch (error) {
    console.error('❌ 发送事件失败:', error);
    return false;
  }
}

// 通知popup连接状态
function notifyConnectionStatus(connected, serverUrl) {
  chrome.runtime.sendMessage({
    type: 'CONNECTION_STATUS',
    connected: connected,
    serverUrl: serverUrl
  }).catch(() => {
    // popup可能未打开，忽略错误
  });
}

// 注册设备
async function registerDevice() {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.log('⚠️ WebSocket未连接，跳过设备注册');
    return;
  }

  if (isRegistering) {
    console.log('⚠️ 设备注册正在进行中，跳过重复注册');
    return;
  }

  try {
    isRegistering = true;
    console.log('🔄 开始设备注册...');
    
    // 设置注册超时
    const registrationTimeout = setTimeout(() => {
      if (isRegistering) {
        console.warn('⚠️ 设备注册超时，重置状态');
        isRegistering = false;
      }
    }, 10000); // 10秒超时
    
    // 生成硬件指纹
    const hardwareFingerprint = await generateEnhancedBrowserFingerprint();
    
    // 准备设备信息
    const deviceInfo = {
      type: 'browser',
      name: 'Chrome Browser',
      capabilities: {
        canReceiveText: true,   // 浏览器设备接收文本
        canSendVoice: false,    // 浏览器设备不发送语音
        canGenerateQR: true,    // 浏览器设备生成二维码
        canScanQR: false        // 浏览器设备不扫描二维码
      },
      hardwareFingerprint: hardwareFingerprint
    };

    console.log('📝 注册设备:', deviceInfo);
    emitSocketEvent('device:register', deviceInfo);
    
    // 清理超时定时器
    clearTimeout(registrationTimeout);
  } catch (error) {
    console.error('❌ 设备注册失败:', error);
    isRegistering = false;
  }
}

// 开始配对
async function startPairing() {
  console.log('🔄 开始配对...');

  if (!currentServer) {
    console.error('❌ 未连接到服务器');
    return false;
  }

  // 确保设备ID已初始化
  if (!deviceId) {
    console.log('⚠️ 设备ID未初始化，正在初始化...');
    const result = await chrome.storage.local.get(['deviceId']);
    if (!result.deviceId) {
      // 使用基于浏览器指纹的唯一ID
      deviceId = await generateBrowserUniqueDeviceId();
      await chrome.storage.local.set({ deviceId });
      console.log('🆕 生成浏览器唯一设备ID:', deviceId);
    } else {
      deviceId = result.deviceId;
      console.log('🔄 加载现有设备ID:', deviceId);
    }
  }

  try {
    // 使用HTTP API生成配对码
    console.log('🌐 使用HTTP API生成配对码');
    console.log(`📡 请求URL: ${currentServer}/api/pairing/generate`);
    console.log('📝 设备信息:', { deviceId, deviceType: 'browser', deviceName: 'Chrome Browser' });

    const response = await fetch(`${currentServer}/api/pairing/generate`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      body: JSON.stringify({
        deviceId: deviceId,
        deviceType: 'browser',
        deviceName: 'Chrome Browser'
      })
    });

    console.log('📡 响应状态:', response.status, response.statusText);

    if (!response.ok) {
      const errorText = await response.text();
      console.error('❌ HTTP错误响应:', errorText);
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const data = await response.json();
    console.log('✅ 配对码生成成功 (服务端原始数据):', data);

    // 通知popup显示配对码
    if (data.success) {
      console.log('📱 即将发送给Popup的数据:', {
        type: 'PAIRING_CODE',
        code: data.code,
        qrCode: data.qrCode || null
      });
      chrome.runtime.sendMessage({
        type: 'PAIRING_CODE',
        code: data.code,
        qrCode: data.qrCode || null
      }).catch(() => {});

      return true;
    } else {
      throw new Error(data.message || '配对码生成失败');
    }

  } catch (error) {
    console.error('❌ 配对请求失败:', error);

    // 通知popup配对失败
    chrome.runtime.sendMessage({
      type: 'PAIRING_FAILED',
      error: `启动配对失败: ${error.message}`
    }).catch(() => {});

    return false;
  }
}

// 处理语音文本
function handleVoiceText(data) {
  console.log('🎤 处理语音文本:', data);
  
  // 发送到当前活动标签页
  chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
    if (tabs[0]) {
      // 发送新的VOICE_TEXT消息类型
      chrome.tabs.sendMessage(tabs[0].id, {
        type: 'VOICE_TEXT',
        text: data.text,
        confidence: data.confidence || 1.0
      }).catch((error) => {
        console.log('发送语音文本到页面失败:', error);
        
        // 如果新消息类型失败，尝试旧的消息类型
        chrome.tabs.sendMessage(tabs[0].id, {
          type: 'INSERT_TEXT',
          text: data.text,
          confidence: data.confidence || 1.0
        }).catch((fallbackError) => {
          console.log('发送文本到页面失败 (回退):', fallbackError);
        });
      });
    } else {
      console.log('❌ 未找到活动标签页');
    }
  });
}

// 重置连接
function resetConnection() {
  console.log('🔄 重置连接状态');
  
  // 清理WebSocket连接
  if (ws) {
    ws.close();
    ws = null;
  }
  
  // 清理心跳定时器
  if (heartbeatInterval) {
    clearInterval(heartbeatInterval);
    heartbeatInterval = null;
  }
  
  // 重置状态
  isConnected = false;
  currentServer = null;
  reconnectAttempts = 0;
  
  // 通知popup连接状态变化
  notifyConnectionStatus(false, null);
  
  // 重新连接
  connectToServer();
}

// 同步服务器配对状态
async function syncPairingStatus() {
  if (!currentServer || !deviceId) {
    console.log('⚠️ 无法同步配对状态：服务器未连接或设备ID未初始化');
    return;
  }

  try {
    console.log('🔄 同步服务器配对状态...');
    
    // 获取设备的配对关系
    const response = await fetch(`${currentServer}/api/devices/${deviceId}`, {
      method: 'GET',
      headers: {
        'Accept': 'application/json'
      }
    });

    if (response.ok) {
      const data = await response.json();
      console.log('📡 服务器配对状态响应:', data);
      
      if (data.success && data.data && data.data.pairings) {
        console.log('📊 原始配对关系数据:', data.data.pairings);
        
        // 更新本地配对设备列表
        const serverPairedDevices = new Set();
        
        data.data.pairings.forEach((pairing, index) => {
          console.log(`🔍 处理配对关系 ${index + 1}:`, {
            device1Id: pairing.device1Id,
            device2Id: pairing.device2Id,
            device1Name: pairing.device1Name,
            device2Name: pairing.device2Name,
            currentDeviceId: deviceId
          });
          
          // 找到与当前设备配对的另一个设备
          const otherDeviceId = pairing.device1Id === deviceId ? pairing.device2Id : pairing.device1Id;
          if (otherDeviceId) {
            serverPairedDevices.add(otherDeviceId);
            console.log(`✅ 添加配对设备: ${otherDeviceId}`);
          } else {
            console.log(`⚠️ 未找到配对设备，当前设备ID: ${deviceId}`);
          }
        });
        
        // 更新本地状态
        pairedDevices.clear();
        serverPairedDevices.forEach(deviceId => pairedDevices.add(deviceId));
        
        // 保存到本地存储
        chrome.storage.local.set({ pairedDevices: Array.from(pairedDevices) });
        
        console.log('✅ 配对状态同步完成:', Array.from(pairedDevices));
        
        // 通知popup更新状态
        chrome.runtime.sendMessage({
          type: 'PAIRING_STATUS_SYNCED',
          pairedDevices: Array.from(pairedDevices)
        }).catch(() => {});
      } else {
        console.log('⚠️ 服务器返回数据格式不正确:', data);
      }
    } else {
      console.warn('⚠️ 获取配对状态失败:', response.status);
    }
  } catch (error) {
    console.error('❌ 同步配对状态失败:', error);
  }
}

// 扩展安装时初始化
chrome.runtime.onInstalled.addListener(async () => {
  console.log('🚀 SmartInput 扩展已安装');
  
  // 初始化设备ID和配对设备列表
  await ensureDeviceIdInitialized();
  
  console.log('📱 设备ID:', deviceId);
  console.log('📱 配对设备:', Array.from(pairedDevices));
  
  // 安装时尝试连接一次
  if (!isConnected) {
    connectToServer();
  }
});

// 扩展启动时连接服务器
chrome.runtime.onStartup.addListener(async () => {
  console.log('🔄 SmartInput 扩展启动');
  
  // 确保设备ID和配对设备列表已加载
  await ensureDeviceIdInitialized();
  
  console.log('📱 启动时设备ID:', deviceId);
  console.log('📱 启动时配对设备:', Array.from(pairedDevices));
  
  // 启动时尝试连接一次
  if (!isConnected) {
    connectToServer();
  }
});

// 当插件图标被点击时，也检查一下连接
chrome.action.onClicked.addListener(() => {
  if (!isConnected) {
    console.log('插件图标点击，连接不存在，尝试重连...');
    connectToServer();
  }
});

// 监听来自popup和content script的消息
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  console.log('📨 收到消息:', message.type, message);
  
  switch (message.type) {
    case 'GET_STATUS':
      sendResponse({
        connected: isConnected,
        deviceId: deviceId,
        pairedDevices: Array.from(pairedDevices),
        currentServer: currentServer,
        autoInsert: true // 默认启用自动录入
      });
      break;
      
    case 'START_PAIRING':
      startPairing().then(success => {
        sendResponse({ success });
      });
      return true; // 异步响应
      
    case 'RECONNECT':
      resetConnection();
      sendResponse({ success: true });
      break;
      
    case 'SYNC_PAIRING_STATUS':
      syncPairingStatus().then(() => {
        sendResponse({ success: true });
      }).catch((error) => {
        sendResponse({ success: false, error: error.message });
      });
      return true; // 异步响应
      
    case 'TOGGLE_AUTO_INSERT':
      // 转发到当前活动标签页
      chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
        if (tabs[0]) {
          chrome.tabs.sendMessage(tabs[0].id, {
            type: 'TOGGLE_AUTO_INSERT',
            enabled: message.enabled
          }).catch(() => {
            // 忽略错误，可能页面没有内容脚本
          });
        }
      });
      sendResponse({ success: true });
      break;
      
    default:
      sendResponse({ error: 'Unknown message type' });
  }
});

console.log('✅ SmartInput 后台脚本已加载');
